/**
 * MySQL
 * 封装数据的 【增】【删】【改】【查】 操作
 *
 */
const DB = require('./config');
const dataHander = require('./DataHanderClass');
const log = require('../../common/log');


class CURDClass {
    constructor() {}

    /**
     * 【增】
     * @param sql json数据
     *
     * demo: await CURD.insert({fields:'username,phone',values:'"hahaah",1591021111',table:"user_info"});
     */
    insert(sql) {
        return new Promise((resolve, reject) => {
            DB.getConnection(connection => {

                let initedData = dataHander.initField(sql);

                let s = `INSERT INTO \`${global.TABLE_PREFIX}_${sql.table}\` (${initedData.f}) VALUES (${initedData.v})`;

                // console.log(`插入-字段：${initedData.f}`);
                // console.log(`插入-值：${initedData.v}`);
                log.sql(`插入-sql:${s}`, 'zeng');

                connection.query(s, (err, rows) => {
                    if (err)
                        reject('数据插入报错：' + err);
                    else
                        resolve(rows);

                    // 结束会话
                    connection.release();
                })
            })
        })
    }


    /**
     *【删】
     * @param sql json数据
     *
     * demo: await CURD.delete({table:'user_info',where: [
            {
                wfield: 'id',
                wvalue: id
            }
        ]})
     */
    delete(sql) {
        return new Promise((resolve, reject) => {
            DB.getConnection(connection => {

                // 防sql注入
                if (sql.where) {
                    sql.where = dataHander.noInjection(sql.where)
                }

                let s = `delete from \`${global.TABLE_PREFIX}_${sql.table}\` where ${sql.where} limit 1`;

                console.log(`删除条件：${sql.where}`);
                log.sql(`sql:${s}`);

                connection.query(s, (err, rows) => {
                    if (err)
                        reject('数据删除报错：' + err)
                    else
                        resolve(rows)

                    // 结束会话
                    connection.release()
                })

            })
        })
    }


    /**
     *【改】
     * @param sql json数据
     *
     * demo : await CURD.update({table:'user_info',fields:["phone=150000000", "username='xxxxx'"],where: [
            {
                wfield: 'id',
                wvalue: id
            }
        ]})
     */
    update (sql) {
        if (!sql.where) sql.where = `1=${pool.escape(1)}`;

        return new Promise((resolve, reject) => {
            DB.getConnection(connection => {

                // 防sql注入
                if (sql.where) {
                    sql.where = dataHander.noInjection(sql.where)
                }

                let f = sql.fields;
                let temp = '';
                for (let i in f) {
                    temp += f[i] + ',';
                }
                f = temp.substr(0, temp.length - 1);

                let s = `UPDATE \`${global.TABLE_PREFIX}_${sql.table}\` SET ${f} WHERE ${sql.where}`;

                // console.log(`修改字段：${f}`);
                // console.log(`修改条件：${sql.where}`);
                console.log(`sql:${s}`);

                connection.query(s, (err, rows) => {
                    if (err)
                        reject('数据修改报错：' + err)
                    else
                        resolve(rows)

                    // 结束会话
                    connection.release()
                })
            })
        })
    }


    /**
     *【查】
     * @param sql json数据
     *  demo: await CURD.select({
     *  field:'id,username',
     *  table:'user_info',
     *  where: [
                {
                    wfield: 'cid',
                    wvalue: cid
                }
            ],
         limit: '0, 10'
     *  })
     */
    select(sql) {
        // 返回一个 Promise
        return new Promise((resolve, reject) => {
            DB.getConnection(connection => {

                if (!sql.where) {
                    sql.where = `1=${connection.escape(1)}`;
                } else {
                    // 防sql注入
                    sql.where = dataHander.noInjection(sql.where);
                }
                if (sql.limit) sql.limit = `limit ${sql.limit}`;


                let s = `SELECT ${sql.fields} FROM \`${global.TABLE_PREFIX}_${sql.table}\` WHERE ${sql.where} ${sql.order ? `ORDER BY ${sql.order}` : ''} ${sql.limit ? sql.limit : 'LIMIT 0,1'}`;
                log.sql(s, 'cha');

                if (sql.where) log.msg(`查询-条件:${sql.where}`, 1);

                connection.query(s, (err, rows) => {
                    if (err) {
                        reject('数据查询报错：' + err)
                    } else {
                        resolve(rows);

                        // 结束会话
                        connection.release()
                    }
                })
            })
        })
    }


    /**
     *【原生sql】
     * @param sql sql语句，直接执行
     * 联查：select ${fields} from xhpx_user U left join xhpx_user_info UINFO on U.uid = UINFO.uid where U.uid = '${uid}'
     */
    other(sql) {
        return new Promise((resolve, reject) => {
            DB.getConnection(connection => {

                    log.sql(`sql:${sql}`);

                    connection.query(sql, (err, rows) => {
                        if (err)
                            reject('操作sql有误：' + err)
                        else
                            resolve(rows)

                        // 结束会话
                        connection.release()
                    })
            })
        })
    }

    /**
     * 事务方式插入数据
     * @param sql {}
     */
    transaction(sql) {
        // let data = [
        //     {
        //         table: 'user_login',
        //         fields: 'phone,password',
        //         values: '15910277443,11111111',
        //         relation: {
        //             fromeField:'id',
        //         }
        //     }, {
        //         table: 'user_info',
        //         fields: 'phone,uid',
        //         values: '15910277443,111',
        //         relation: {
        //             updateField:'uuid',
        //         }
        //     }
        // ]
        // CURD.transaction(data);
        return new Promise((resolve, reject) => {
            var transactionList = new Array();
            DB.getConnection(function (connection) {
                connection.beginTransaction(function (err) {
                    if (err) {
                        reject('事务创建失败：' + err);
                        return;
                    }

                    let relation = {};
                    sql.forEach((val, key) => {
                        // 循环创建事务处理函数，操作几个表就创建几个函数
                        transactionList[key] = function (callback) {

                            // 是否需要关联上一个表的字段
                            let rel = val.relation ? val.relation : '';
                            if (rel && rel.updateField) {
                                val.fields += ','+rel.updateField;
                                val.values += `,${relation.id}`;
                            }

                            let data = dataHander.initField(val);
                            let s = `INSERT INTO ${global.TABLE_PREFIX}_${val.table} (${data.f}) VALUES (${data.v})`;

                            console.log(s);

                            connection.query(s, function (err, result) {
                                if (err) {
                                    reject('sql语句执行失败：'+err);
                                    callback(err, null);
                                    return;
                                }

                                // 是否需要给下一个表返回关联字段
                                if (rel && rel.fromeField) {
                                    relation.id = result.insertId;
                                }

                                console.log(`第${key}次插入成功!`);
                                callback(null, result);
                            })
                        }
                    });

                    async.series(transactionList, function (err, result) {
                        if (err) {
                            //回滚
                            connection.rollback(function () {
                                reject('事务执行错误,回滚：'+ err);
                                //释放资源
                                connection.release();
                            });
                            return;
                        }

                        //提交
                        connection.commit(function (err) {
                            if (err) {
                                reject('事务提交错误：'+ err);
                                return;
                            }

                            console.log('事务执行成功,OK!');
                            //释放资源
                            connection.release();
                        });
                    });
                });
            });
        });
    }
}

module.exports = new CURDClass();